package com.jeesite.modules.task.audit.service;

import com.jeesite.common.entity.Page;
import com.jeesite.common.idgen.IdGen;
import com.jeesite.common.lang.StringUtils;
import com.jeesite.common.service.CrudService;
import com.jeesite.modules.backlog.entity.DcSupBacklog;
import com.jeesite.modules.backlog.service.DcSupBacklogService;
import com.jeesite.modules.common.dao.SysBasicDao;
import com.jeesite.modules.common.entity.SysBasicUser;
import com.jeesite.modules.common.service.SysMsgService;
import com.jeesite.modules.file.utils.FileUploadUtils;
import com.jeesite.modules.msg.entity.content.PcMsgContent;
import com.jeesite.modules.msg.utils.MsgPushUtils;
import com.jeesite.modules.sys.utils.UserUtils;
import com.jeesite.modules.task.action.dao.DcSupTaskActionDao;
import com.jeesite.modules.task.action.entity.DcSupTaskAction;
import com.jeesite.modules.task.action.service.DcSupTaskActionService;
import com.jeesite.modules.task.arrange.service.DcSupTaskInfoArrangeService;
import com.jeesite.modules.task.audit.dao.DcSupTaskAuditDao;
import com.jeesite.modules.task.audit.entity.*;
import com.jeesite.modules.task.deploy.dao.DcSupTaskInfoAddDao;
import com.jeesite.modules.task.deploy.entity.DcSupTaskInfo;
import com.jeesite.modules.task.deploy.entity.DcSupTaskInfoAdd;
import com.jeesite.modules.task.deploy.entity.DcSupTaskInfoRefine;
import com.jeesite.modules.task.deploy.entity.OfficeUser;
import com.jeesite.modules.task.deploy.service.DcSupTaskInfoRefineService;
import com.jeesite.modules.task.deploy.service.DcSupTaskInfoService;
import com.jeesite.modules.task.feedback.dao.DcSupTaskFeedbackDao;
import com.jeesite.modules.task.feedback.entity.DcSupTaskFeedback;
import com.jeesite.modules.task.feedback.service.DcSupTaskFeedbackService;
import com.jeesite.modules.task.status.service.DcSupTaskStatusService;
import com.jeesite.modules.utils.Dict;
import com.jeesite.modules.yzw.entity.MsgDetail;
import com.jeesite.modules.yzw.service.LehandYzwPushTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;

/**
 * 任务过程审核表Service
 * @author zrr
 * @version 2022-03-02
 */
@Service
@Transactional(readOnly=false)
public class DcSupTaskAuditService extends CrudService<DcSupTaskAuditDao, DcSupTaskAudit> {
	@Autowired
	private DcSupTaskInfoService dcSupTaskInfoService;
	@Autowired
	private DcSupTaskFeedbackService dcSupTaskFeedbackService;
	@Autowired
	private DcSupTaskInfoArrangeService dcSupTaskInfoArrangeService;
	@Autowired
	private DcSupTaskAuditAddService dcSupTaskAuditAddService;
	@Autowired
	private DcSupTaskStatusService dcSupTaskStatusService;
	@Autowired
	private DcSupTaskActionService dcSupTaskActionService;
	@Autowired
	private DcSupTaskInfoRefineService dcSupTaskInfoRefineService;
	@Resource
	private SysBasicDao sysBasicDao;
	@Resource
	private DcSupTaskActionDao dcSupTaskActionDao;
	@Autowired
	private LehandYzwPushTask lehandYzwPushTask;
	@Autowired
	private DcSupTaskFeedbackDao dcSupTaskFeedbackDao;
	@Autowired
	private DcSupTaskInfoAddDao dcSupTaskInfoAddDao;
	@Autowired
	private SysMsgService sysMsgService;
	@Autowired
	private DcSupBacklogService dcSupBacklogService;
	
	/**
	 * 获取单条数据
	 * @param dcSupTaskAudit
	 * @return
	 */
	@Override
	public DcSupTaskAudit get(DcSupTaskAudit dcSupTaskAudit) {
		return super.get(dcSupTaskAudit);
	}
	
	/**
	 * 查询分页数据
	 * @param dcSupTaskAudit 查询条件
	 * @return
	 */
	@Override
	public Page<DcSupTaskAudit> findPage(DcSupTaskAudit dcSupTaskAudit) {
		return super.findPage(dcSupTaskAudit);
	}
	
	/**
	 * 查询列表数据
	 * @param dcSupTaskAudit
	 * @return
	 */
	@Override
	public List<DcSupTaskAudit> findList(DcSupTaskAudit dcSupTaskAudit) {
		return super.findList(dcSupTaskAudit);
	}

	/**
	 * 保存数据（插入或更新）
	 * @param dcSupTaskAudit
	 */
	@Override
	@Transactional(readOnly=false)
	public void save(DcSupTaskAudit dcSupTaskAudit) {
		super.save(dcSupTaskAudit);
		// 保存上传图片
		FileUploadUtils.saveFileUpload(dcSupTaskAudit, dcSupTaskAudit.getId(), "dcSupTaskAudit_image");
		// 保存上传附件
		FileUploadUtils.saveFileUpload(dcSupTaskAudit, dcSupTaskAudit.getId(), "dcSupTaskAudit_file");
	}

	/**
	 * 更新状态
	 * @param dcSupTaskAudit
	 */
	@Override
	@Transactional(readOnly=false)
	public void updateStatus(DcSupTaskAudit dcSupTaskAudit) {
		super.updateStatus(dcSupTaskAudit);
	}

	/**
	 * 删除数据
	 * @param dcSupTaskAudit
	 */
	@Override
	@Transactional(readOnly=false)
	public void delete(DcSupTaskAudit dcSupTaskAudit) {
		super.delete(dcSupTaskAudit);
	}

	/**
	 * 根据审核类型查找分页数据
	 * @param dcSupTaskAudit
	 * @return
	 */
	public Page<DcSupTaskAudit> findPageByAuditType(DcSupTaskAudit dcSupTaskAudit) {
		String auditType = dcSupTaskAudit.getAuditType();
		Page<DcSupTaskAudit> page = dcSupTaskAudit.getPage();
		List<DcSupTaskAudit> list = new ArrayList<>();

		if (auditType.equals("deploy")) {
			// 任务部署审核
			list = dao.getAuditListDeploy(dcSupTaskAudit);
		} else if (auditType.equals("feedback")) {
			// 任务反馈审核
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditStatus())) {
				list = dao.getAuditListFeedback(dcSupTaskAudit);
			} else {
				list = dao.getAuditListedFeedback(dcSupTaskAudit);
			}
		} else if (auditType.equals("arrange")) {
			// 任务整理审核
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditStatus())) {
				list = dao.getAuditListArrange(dcSupTaskAudit);
			} else {
				list = dao.getAuditListedArrange(dcSupTaskAudit);
			}
		} else {
			// 任务细化分解审核
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditStatus())) {
				list = dao.getAuditListRefine(dcSupTaskAudit);
			} else {
				list = dao.getAuditListedRefine(dcSupTaskAudit);
			}
		}

		// 放入查询结果
		page.setList(list);

		return page;
	}

	/**
	 * 通过年份、督办字号、标题、类型查询其子项
	 * @param dcSupTaskAudit
	 * @return
	 */
	public Page<DcSupTaskAudit> getListDataChild(DcSupTaskAudit dcSupTaskAudit) {
		Page<DcSupTaskAudit> page = dcSupTaskAudit.getPage();
		List<DcSupTaskAudit> list = new ArrayList<>();
		if (StringUtils.equals("1", dcSupTaskAudit.getAuditStatus())) {
			list = dao.getAuditListDeployByParent(dcSupTaskAudit);
		} else {
			list = dao.getAuditListedDeployByParent(dcSupTaskAudit);
		}

		page.setList(list);
		return page;
	}

	/**
	 * 查询审核记录数据
	 * @param dcSupTaskAudit
	 * @return
	 */
	public Page<DcSupTaskAudit> getAuditListRecord(DcSupTaskAudit dcSupTaskAudit) {
		Page<DcSupTaskAudit> page = dcSupTaskAudit.getPage();
		List<DcSupTaskAudit> list = dao.getAuditListRecord(dcSupTaskAudit);
		page.setList(list);
		return page;
	}
	
	/**
	 * 保存数据（插入或更新）
	 * 当审核结果为驳回时，需要更新原始数据状态，审核状态和子表数据状态
	 * 当审核结构为通过时，既要更新原始数据状态，审核状态和子表数据状态，又要插入下一步数据
	 * @param dcSupTaskAudit
	 */
	@Transactional(readOnly=false)
	public String saveAudit(DcSupTaskAudit dcSupTaskAudit) {
		// 记录异常反馈结果，如果正常则为空
		String resultWord = "";
		// 参数校验，检查审核结果是否为空
		if (StringUtils.isNotBlank(dcSupTaskAudit.getAuditResult())) {
			// 如果一个审核可以被多个人操作，需要检查重复提交
			// 任务反馈科室审核需要检查
			if (StringUtils.equals(Dict.AuditType.TYPE_4, dcSupTaskAudit.getAuditType())) {
				// 获取审核数据
				DcSupTaskAudit taskAudit = this.get(dcSupTaskAudit);
				if (StringUtils.equals("2", taskAudit.getAuditStatus())) {
					// 此审核已被审理
					resultWord = "此审核已被其他人员审理，请关闭当前页面并刷新待审核列表";
					return resultWord;
				}
			}

			// 修改审核状态为已审核
			dcSupTaskAudit.setAuditStatus("2");
			// 记录审核时间
			dcSupTaskAudit.setAuditTime(new Date());

			// 根据审核类型，判断下一步审核流程
			if (StringUtils.equals(Dict.TargetType.TYPE_1, dcSupTaskAudit.getTargetType())) {
				// 任务部署
				this.saveAuditDeploy(dcSupTaskAudit);
			}
			if (StringUtils.equals(Dict.TargetType.TYPE_2, dcSupTaskAudit.getTargetType())) {
				// 任务反馈
				resultWord = this.saveAuditFeedback(dcSupTaskAudit);
			}
			if (StringUtils.equals(Dict.TargetType.TYPE_3, dcSupTaskAudit.getTargetType())) {
				// 任务整理
				this.saveAuditArrange(dcSupTaskAudit);
			}
			if (StringUtils.equals(Dict.TargetType.TYPE_4, dcSupTaskAudit.getTargetType())) {
				// 任务细化分解
				this.saveAuditRefine(dcSupTaskAudit);
			}
		} else {
			resultWord = "审核结果为空！";
		}

		return resultWord;
	}

	/**
	 * 任务部署，审核保存处理
	 * @param dcSupTaskAudit
	 * @return
	 */
	public void saveAuditDeploy(DcSupTaskAudit dcSupTaskAudit) {
		// 普通任务部署审核人审核
		if (StringUtils.equals(Dict.AuditType.TYPE_1, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				// 通过后，修改任务状态为，任务部署审核通过
				dcSupTaskInfoService.updateTaskStatus(dcSupTaskAudit.getTargetId(), Dict.TaskStatus.STATUS_3);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "1", Dict.TaskStatus.STATUS_3, "任务部署审核通过");
				// 将任务分发给牵头责任单位★
				DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getDcSupTaskInfo().getId());
				dcSupTaskInfoService.confirm(dcSupTaskInfo);
				//任务审核成功后置为已办
				dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_deploy");
			} else {
				// 驳回后，修改任务状态为，任务部署审核驳回
				dcSupTaskInfoService.updateTaskStatus(dcSupTaskAudit.getTargetId(), Dict.TaskStatus.STATUS_4);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "1", Dict.TaskStatus.STATUS_4, "任务部署审核驳回");
				// 通知被驳回人
				// 2普任务部署:审核人驳回，向任务部署人发送消息
				// 2秘任务部署:审核人驳回，向任务部署人发送消息
				// 2细任务部署:审核人驳回，向任务部署人发送消息
				this.pushMsg(dcSupTaskAudit);
			}
			//任务部署待审核置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_deploy");
			// 用户提交审核时，将此处的单条消息置为已读
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_deploy", UserUtils.getUser().getUserCode());
		}

		// 任务部署秘书长审核
		// 秘书一科任务部署时，只有秘书长审核，没有普通审核
		if (StringUtils.equals(Dict.AuditType.TYPE_2, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				// 审核通过
				// 秘书长可以修改任务，判断是否有修改
				DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
				DcSupTaskInfo dcSupTaskInfoTemp = dcSupTaskAudit.getDcSupTaskInfo();
				// 检查任务是否改变
				if (!dcSupTaskInfoEquals(dcSupTaskInfoTemp,dcSupTaskInfo)) {
					// 有修改则更新
					dcSupTaskInfoTemp.setNormalFlag("2");
					dcSupTaskInfoService.uniqueMessageNumber(dcSupTaskInfoTemp);
					dcSupTaskInfoTemp.setTaskStatus(Dict.TaskStatus.STATUS_5);
					dcSupTaskInfoService.update(dcSupTaskInfoTemp);
					if (StringUtils.isNotBlank(dcSupTaskInfoTemp.getId())) {
						DcSupTaskFeedback deleteFeedback = new DcSupTaskFeedback();
						deleteFeedback.setTaskId(dcSupTaskInfoTemp.getId());
						dcSupTaskFeedbackDao.deleteByEntity(deleteFeedback);
						//插入分解后的反馈时间
						DcSupTaskInfoAdd dcdelete = new DcSupTaskInfoAdd();
						dcdelete.setTaskId(dcSupTaskInfoTemp.getId());
						dcSupTaskInfoAddDao.deleteByEntity(dcdelete);
					}
					dcSupTaskInfoService.batchSaveTaskAddTime(dcSupTaskInfoTemp);
					// 保存上传图片
					FileUploadUtils.saveFileUpload(dcSupTaskInfoTemp, dcSupTaskInfoTemp.getId(), "dcSupTaskInfo_image");
					// 保存上传附件
					FileUploadUtils.saveFileUpload(dcSupTaskInfoTemp, dcSupTaskInfoTemp.getId(), "dcSupTaskInfo_file");
				}
				// 通过后，修改任务状态为，秘书长审核通过
				dcSupTaskInfoService.updateTaskStatus(dcSupTaskAudit.getTargetId(), Dict.TaskStatus.STATUS_5);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "1", Dict.TaskStatus.STATUS_5, "任务部署秘书长审核通过");
				// 需要科室确认才能分发任务，此处不用分发
				// 3秘 任务部署，审核人审核通过，给其他科室发确认任务的消息
				List<SysBasicUser> officeMembers = sysBasicDao.getUserByOfficeAndRole(dcSupTaskInfo.getTaskSupOrg(), "SECRETARY_ONE");

				for (SysBasicUser user : officeMembers) {
//					PcMsgContent msg = new PcMsgContent();
//					msg.setTitle("提示信息");
//					msg.setContent("您有一个任务:\"" + dcSupTaskInfo.getTaskTitle() + "\"待确认,请及时查看");
//					msg.addButton("任务确认", "/a/taskdeploy/dcSupTaskInfo/dcSupTaskConfirmList");
//					MsgPushUtils.push(msg, dcSupTaskInfo.getId() + "_" + dcSupTaskInfo.getTaskSupOrg(), "confirm_deploy", user.getUserCode());
					//发送易政网消息
					MsgDetail msgDetail = new MsgDetail();
					msgDetail.setSendid(UserUtils.getUser().getUserCode());
					msgDetail.setSubjectid(user.getUserCode());
					msgDetail.setMesg("您有一个任务:\"" + dcSupTaskInfo.getTaskTitle() + "\"待确认,请及时登录系统查看");
					lehandYzwPushTask.pushYzwShortMsg(msgDetail);
				}
				//新增待办
				dcSupBacklogService.addBasic("督查督办","任务确认","任务确认","提示信息"
						,"您有一个任务:" + dcSupTaskInfo.getTaskTitle() + "待确认,请及时查看"
						,"/a/taskdeploy/dcSupTaskInfo/dcSupTaskConfirmList",dcSupTaskInfo.getTaskSupOrg()
						,dcSupTaskInfo.getId(),"task_confirm",officeMembers
						,dcSupTaskInfo.getId(),"");
			} else {
				// 驳回后，修改任务状态为，秘书长审核驳回
				dcSupTaskInfoService.updateTaskStatus(dcSupTaskAudit.getTargetId(), Dict.TaskStatus.STATUS_6);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "1", Dict.TaskStatus.STATUS_6, "任务部署秘书长审核驳回");
				// 通知被驳回人
				this.pushMsg(dcSupTaskAudit);
			}
			//任务部署待审核置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_deploy");
			// 用户提交审核时，将此处的单条消息置为已读
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_deploy", UserUtils.getUser().getUserCode());
			// 对于秘书一科任务部署，一键发布，需要再单独清除
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getTaskId(), "audit_deploy", UserUtils.getUser().getUserCode());
		}

		// 细化分解任务部署审核人审核
		if (StringUtils.equals(Dict.AuditType.TYPE_7, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				// 通过后，修改任务状态为，细化分解任务部署审核通过
				dcSupTaskInfoService.updateTaskStatus(dcSupTaskAudit.getTargetId(), Dict.TaskStatus.STATUS_3);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "1", Dict.TaskStatus.STATUS_3, "细化分解任务部署审核通过");
				// 将细化分解任务，插入到细化分解子表中★
				DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getDcSupTaskInfo().getId());
				dcSupTaskInfoRefineService.generateRefine(dcSupTaskInfo);
				//3细任务部署，向所有牵头单位的【任务收文员】角色用户发送消息，让确认分阶段目标
				Thread thread = new Thread(() -> {
					String [] orgs = dcSupTaskInfo.getTaskLeaderOrg().split(",");
					for (int i = 0; i < orgs.length; i++) {
						List<OfficeUser> userByOrg = dcSupTaskActionDao.getUserByOrg("OTSTRANSFER",orgs[i]);
						for (OfficeUser user: userByOrg) {
//							PcMsgContent msg = new PcMsgContent();
//							msg.setTitle("提示信息");
//							msg.setContent("您有一个任务:\""+dcSupTaskInfo.getTaskTitle()+"\"的分阶段目标待报送,请及时查看");
//							msg.addButton("分阶段报送", "/a/taskdeploy/dcSupTaskInfoRefine/refineList");
//							MsgPushUtils.push(msg, dcSupTaskInfo.getId() + "_" + orgs[i], "confirm_refine", user.getUserCode());
							//发送易政网消息
							MsgDetail msgDetail = new MsgDetail();
							msgDetail.setSendid(UserUtils.getUser().getUserCode());
							msgDetail.setSubjectid(user.getUserCode());
							msgDetail.setMesg("您有一个任务:\""+dcSupTaskInfo.getTaskTitle()+"\"的分阶段目标待报送,请及时登录系统查看");
							lehandYzwPushTask.pushYzwShortMsg(msgDetail);
						}
						//新增待办
						dcSupBacklogService.addOffice("督查督办","任务阶段目标报送","任务阶段目标报送","提示信息"
								,"您有一个任务:"+dcSupTaskInfo.getTaskTitle()+"的分阶段目标待报送,请及时查看"
								,"/a/taskdeploy/dcSupTaskInfoRefine/refineList",orgs[i]
								,dcSupTaskInfo.getId(),"task_refine",userByOrg
								,dcSupTaskInfo.getId(),"");
					}
				});
				thread.start();


			} else {
				// 驳回后，修改任务状态为，细化分解任务部署审核驳回
				dcSupTaskInfoService.updateTaskStatus(dcSupTaskAudit.getTargetId(), Dict.TaskStatus.STATUS_4);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "1", Dict.TaskStatus.STATUS_4, "细化分解任务部署审核驳回");
				// 通知被驳回人
				this.pushMsg(dcSupTaskAudit);
			}
			//任务部署待审核置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_deploy");
			// 用户提交审核时，将此处的单条消息置为已读
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_deploy", UserUtils.getUser().getUserCode());
		}

		// 保存审核结果
		super.save(dcSupTaskAudit);
	}

	public boolean dcSupTaskInfoEquals(DcSupTaskInfo dcSupTaskInfoTemp, DcSupTaskInfo dcSupTaskInfo) {
		if(
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskYear(),dcSupTaskInfo.getTaskYear()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskTypeCode(),dcSupTaskInfo.getTaskTypeCode()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskTitle(),dcSupTaskInfo.getTaskTitle()) ||
			!dcSupTaskInfoTemp.getTaskStartTime().equals(dcSupTaskInfo.getTaskStartTime()) ||
			!dcSupTaskInfoTemp.getTaskEndTime().equals(dcSupTaskInfo.getTaskEndTime()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskTypeCode(),dcSupTaskInfo.getTaskTypeCode()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskCoopOrg(),dcSupTaskInfo.getTaskCoopOrg()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getSortNum(),dcSupTaskInfo.getSortNum()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getFeedbackWay(),dcSupTaskInfo.getFeedbackWay()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getFeedbackRate(),dcSupTaskInfo.getFeedbackRate()) ||
			!DcSupTaskInfoAddListEquals(dcSupTaskInfoTemp.getDcSupTaskInfoAddList(),dcSupTaskInfo.getDcSupTaskInfoAddList()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getMessageNumber(),dcSupTaskInfo.getMessageNumber()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getFormFlag(),dcSupTaskInfo.getFormFlag()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getAttachmentFlag(),dcSupTaskInfo.getAttachmentFlag()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskContent(), dcSupTaskInfo.getTaskContent()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskLeaderOrg(), dcSupTaskInfo.getTaskLeaderOrg()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskSupUser(), dcSupTaskInfo.getTaskSupUser()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskSupOrg(), dcSupTaskInfo.getTaskSupOrg()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getTaskLeader(), dcSupTaskInfo.getTaskLeader()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getContactName(), dcSupTaskInfo.getContactName()) ||
			!StringUtils.equals(dcSupTaskInfoTemp.getContactPhone(), dcSupTaskInfo.getContactPhone())
		){
			return false;
		  }
		return true;
	}

	public boolean DcSupTaskInfoAddListEquals(List<DcSupTaskInfoAdd> dcSupTaskInfoAddList, List<DcSupTaskInfoAdd> dcSupTaskInfoAddList1) {
			if(dcSupTaskInfoAddList.size()!=dcSupTaskInfoAddList1.size()) {
				return false;
			}
			for (int i = 0; i < dcSupTaskInfoAddList.size(); i++) {
				if(
					!dcSupTaskInfoAddList.get(i).getFeedbackStartTime().equals(dcSupTaskInfoAddList1.get(i).getFeedbackStartTime()) ||
					!dcSupTaskInfoAddList.get(i).getFeedbackEndTime().equals(dcSupTaskInfoAddList1.get(i).getFeedbackEndTime())
				){
					return false;
				}
			}
		   return true;
	}

	/**
	 * 任务反馈，审核保存处理
	 * @param dcSupTaskAudit
	 * @return
	 */
	public String saveAuditFeedback(DcSupTaskAudit dcSupTaskAudit) {
		String resultWord = "";
		//修改feedback表的feedback_progress
		DcSupTaskFeedback feedback = new DcSupTaskFeedback();
		feedback.setFeedbackProgress(dcSupTaskAudit.getFeedbackProgress());
		feedback.setFeedbackRate(dcSupTaskAudit.getFeedbackRate());
		feedback.setId(dcSupTaskAudit.getTargetId());
		feedback.setRemarks4(dcSupTaskAudit.getRemarks4());
		dcSupTaskFeedbackService.updateFeedbackProgress(feedback);

		//根据feedback_id查出action
		DcSupTaskAction action = dao.getActionByFeedbackId(dcSupTaskAudit.getTargetId());
		DcSupTaskAction updateAction = new DcSupTaskAction();
		updateAction.setId(action.getId());
		if(dcSupTaskAudit.getFeedbackProgress().equals("1")){//反馈的序时推进
			updateAction.setTaskProgress("3");//任务的序时推进
		}
		if(dcSupTaskAudit.getFeedbackProgress().equals("2")){//反馈的滞后时序
			updateAction.setTaskProgress("1");//任务的进度滞后
		}
		if(dcSupTaskAudit.getFeedbackProgress().equals("3")){//反馈的已完成
			updateAction.setTaskProgress("4");//任务的已完成
		}
		if(dcSupTaskAudit.getFeedbackProgress().equals("4")){//反馈的未完成
			updateAction.setTaskProgress("5");//任务的未完成
		}
		dao.updateActionTaskProgress(updateAction.getTaskProgress(),updateAction.getId());


		DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
		dcSupTaskAudit.setDcSupTaskInfo(dcSupTaskInfo);
		// 任务反馈审核
		if (StringUtils.equals(Dict.AuditType.TYPE_3, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				// 审核通过
				// 设置一个临时变量来记录这条反馈放到审核表中时的id，在消息中使用
				String tempAuditId = "";
				// 获取反馈信息
				DcSupTaskFeedback tempFeedback = dcSupTaskFeedbackService.get(feedback);
				// 获取该条反馈的分发任务信息
				DcSupTaskInfo dcSupTaskInfoRes = dcSupTaskFeedbackService.getInfoByActionId(tempFeedback.getActionId());

				// 对于任务反馈审核，需要判断其是否为秘书一科流程，是，则其下一步是任务部署科室审核，先插入下一步，检查是否有下一步人员
				if (StringUtils.equals("2", dcSupTaskInfo.getNormalFlag())) {
					tempAuditId = IdGen.nextId();
					// 是秘书一科流程，则插入任务反馈科室审核
					resultWord = this.addAuditInfo(tempAuditId, dcSupTaskAudit.getTargetId(), dcSupTaskAudit.getTaskId(), dcSupTaskAudit.getTargetType(), Dict.AuditType.TYPE_4, null, null, "OFFICE_MEMBER");
					if (StringUtils.isBlank(resultWord)) {
						// 通过后，修改反馈状态为，反馈审核通过
						dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_3);
						// 9秘任务反馈，向科室成员发送消息
						List<SysBasicUser> officeMembers = sysBasicDao.getUserByOfficeAndRole(dcSupTaskInfo.getTaskSupOrg(), "SECRETARY_ONE");

						for (SysBasicUser user : officeMembers) {
							PcMsgContent msg = new PcMsgContent();
							msg.setTitle("提示信息");
							msg.setContent("您有一个任务:\"" + dcSupTaskInfo.getTaskTitle() + "\"任务反馈待审核,请及时查看");
							msg.addButton("任务反馈审核", "/a/audit/dcSupTaskAudit/form?id=" + tempAuditId + "&taskLeaderOrgName=" + dcSupTaskInfoRes.getTaskLeaderOrgName());
							MsgPushUtils.push(msg, tempAuditId, "audit_feedback_keshichengyuan", user.getUserCode());
							//发送易政网消息
							MsgDetail msgDetail = new MsgDetail();
							msgDetail.setSendid(UserUtils.getUser().getUserCode());
							msgDetail.setSubjectid(user.getUserCode());
							msgDetail.setMesg("您有一个任务:\"" + dcSupTaskInfo.getTaskTitle() + "\"任务反馈待审核,请及时登录系统查看");
							lehandYzwPushTask.pushYzwShortMsg(msgDetail);
						}
					} else {
						// 科室审核没有找到审核人员
						return resultWord;
					}
				} else {
					// 不是秘书一科流程
					// 通过后，修改反馈状态为，反馈审核通过
					dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_3);
					// 插入任务部署人审核
					tempAuditId = IdGen.nextId();
					this.addAuditInfo(tempAuditId, dcSupTaskAudit.getTargetId(), dcSupTaskAudit.getTaskId(), dcSupTaskAudit.getTargetType(), Dict.AuditType.TYPE_5, dcSupTaskInfo.getCreateBy(), UserUtils.get(dcSupTaskInfo.getCreateBy()).getUserName(), "");
					//2加 反馈指定审核人审核通过后，向部署人发待审核消息
//					PcMsgContent msg = new PcMsgContent();
//					msg.setTitle("提示信息");
//					msg.setContent("您有一个任务:\"" + dcSupTaskInfo.getTaskTitle() + "\"任务反馈待审核,请及时查看");
//					msg.addButton("任务反馈审核", "/a/audit/dcSupTaskAudit/form?id=" + tempAuditId + "&taskLeaderOrgName=" + dcSupTaskInfoRes.getTaskLeaderOrgName());
//					MsgPushUtils.push(msg, tempAuditId, "audit_feedback_bushuren", dcSupTaskInfo.getCreateBy());
					//发送易政网消息
					MsgDetail msgDetail = new MsgDetail();
					msgDetail.setSendid(UserUtils.getUser().getUserCode());
					msgDetail.setSubjectid(dcSupTaskInfo.getCreateBy());
					msgDetail.setMesg("您有一个任务:\"" + dcSupTaskInfo.getTaskTitle() + "\"任务反馈待审核,请及时登录系统查看");
					lehandYzwPushTask.pushYzwShortMsg(msgDetail);
					//新增待办-审核通过向创建人发送审核待办
					dcSupBacklogService.add("督查督办","任务反馈审核","任务反馈部署人审核","提示信息"
							,"您有一个任务:" + dcSupTaskInfoRes.getTaskTitle() + "任务反馈待审核,请及时查看"
							,"/a/audit/dcSupTaskAudit/form?id=" + tempAuditId + "&taskLeaderOrgName=" + dcSupTaskInfoRes.getTaskLeaderOrgName(),""
							,tempAuditId,"task_audit_feedback",dcSupTaskInfoRes.getCreateBy()
							,dcSupTaskInfoRes.getId(),tempFeedback.getActionId());
				}
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "3", Dict.FeedbackStatus.STATUS_3, "反馈审核通过");
			} else {
				// 审核驳回
				// 驳回后，修改反馈状态为，反馈审核驳回
				dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_4);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "3", Dict.FeedbackStatus.STATUS_4, "反馈审核驳回");
				// 通知被驳回人
				// 7普任务反馈，审核人驳回，向反馈人发送消息
				// 8秘任务反馈，审核人驳回，向反馈人发送消息
				// 9细任务反馈，审核人驳回，向反馈人发送消息
				//9普任务反馈，任务部署人驳回，向反馈人发送消息
				//10秘任务反馈，科室成员驳回，向反馈人发送消息
				//11细任务反馈，任务部署人驳回，向反馈人发送消息
				this.pushMsg(dcSupTaskAudit);
			}
			//任务审核成功后置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_feedback");
			// 用户提交审核时，将此处的单条消息置为已读
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_feedback_shenheren", UserUtils.getUser().getUserCode());
		}

		// 任务反馈科室审核
		// 不需要再判断是否是秘书一科流程，如果通过，也不需要再插入任务部署人审核，当前反馈到此结束
		if (StringUtils.equals(Dict.AuditType.TYPE_4, dcSupTaskAudit.getAuditType())) {
			// 反馈终止闭环
			DcSupTaskFeedback dcSupTaskFeedback = dcSupTaskFeedbackService.get(new DcSupTaskFeedback(dcSupTaskAudit.getTargetId()));

			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				if("3".equals(dcSupTaskFeedback.getFeedbackProgress())||"4".equals(dcSupTaskFeedback.getFeedbackProgress())){
					//设置之后的大于此次的反馈截止时间的反馈状态为11已终止
					dcSupTaskFeedbackService.updateLastFeedback("11",dcSupTaskAudit.getTargetId());
					//设置action表状态为4已结束
					dcSupTaskFeedbackService.updateActionStatus("4",dcSupTaskAudit.getTargetId());
				}
				// 通过后，修改反馈状态为，科室审核通过
				dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_5);
				// 判断当前分发任务的反馈是否已审核完，更新分发任务为已完成
				if (dcSupTaskFeedbackService.isZeroAuditFeedback(dcSupTaskAudit.getDcSupTaskFeedback().getActionId())) {
					DcSupTaskAction dcSupTaskAction = new DcSupTaskAction();
					dcSupTaskAction.setId(dcSupTaskAudit.getDcSupTaskFeedback().getActionId());
					dcSupTaskAction.setTaskStatus("4");
					dcSupTaskActionService.update(dcSupTaskAction);
					// 在状态变更表中记录
					dcSupTaskStatusService.addStatus(dcSupTaskAction.getId(), "2", "4", "已结束");
				}
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "3", Dict.FeedbackStatus.STATUS_5, "科室审核通过");
			} else {
				// 驳回后，修改反馈状态为，科室审核驳回
				dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_6);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "3", Dict.FeedbackStatus.STATUS_6, "科室审核驳回");
				// 通知被驳回人
				this.pushMsg(dcSupTaskAudit);
			}
			// 更新审核人信息
			dcSupTaskAudit.setAuditorCode(UserUtils.getUser().getUserCode());
			dcSupTaskAudit.setAuditorName(UserUtils.getUser().getUserName());
			// 将子表中的其他审核人设置为不可用
			this.updateAuditAdd(dcSupTaskAudit);
			//任务审核无论通过驳回置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_feedback");
			// 用户提交审核时，将此处的单条消息置为已读
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_feedback_keshichengyuan", null);
		}

		// 任务部署人审核，普通任务需要
		if (StringUtils.equals(Dict.AuditType.TYPE_5, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				// 反馈终止普通/细化
				DcSupTaskFeedback dcSupTaskFeedback = dcSupTaskFeedbackService.get(new DcSupTaskFeedback(dcSupTaskAudit.getTargetId()));
				if("3".equals(dcSupTaskFeedback.getFeedbackProgress())||"4".equals(dcSupTaskFeedback.getFeedbackProgress())){
					//设置之后的大于此次的反馈截止时间的反馈状态为11已终止
					dcSupTaskFeedbackService.updateLastFeedback("11",dcSupTaskAudit.getTargetId());
					//设置action表状态为4已结束
					dcSupTaskFeedbackService.updateActionStatus("4",dcSupTaskAudit.getTargetId());
				}

				// 通过后，修改反馈状态为，任务部署人审核通过
				dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_9);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "3", Dict.FeedbackStatus.STATUS_9, "任务部署人审核通过");
				// 判断当前分发任务的反馈是否已审核完，更新分发任务为已完成
				if (dcSupTaskFeedbackService.isZeroAuditFeedback(dcSupTaskAudit.getDcSupTaskFeedback().getActionId())) {
					DcSupTaskAction dcSupTaskAction = new DcSupTaskAction();
					dcSupTaskAction.setId(dcSupTaskAudit.getDcSupTaskFeedback().getActionId());
					dcSupTaskAction.setTaskStatus("4");
					dcSupTaskActionService.update(dcSupTaskAction);
					// 在状态变更表中记录
					dcSupTaskStatusService.addStatus(dcSupTaskAction.getId(), "2", "4", "已结束");
				}
			} else {
				// 驳回后，修改反馈状态为，任务部署人审核驳回
				dcSupTaskFeedbackService.updateFeedbackStatusById(dcSupTaskAudit.getTargetId(), Dict.FeedbackStatus.STATUS_10);
				// 在状态变更表中记录
				dcSupTaskStatusService.addStatus(dcSupTaskAudit.getTargetId(), "3", Dict.FeedbackStatus.STATUS_10, "任务部署人审核驳回");
				// 通知被驳回人
				this.pushMsg(dcSupTaskAudit);
			}
			//任务审核无论通过驳回置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_feedback");
			// 用户提交审核时，将此处的单条消息置为已读
			sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_feedback_bushuren", UserUtils.getUser().getUserCode());
		}

		// 保存审核结果
		if (StringUtils.isBlank(resultWord)) {
			super.save(dcSupTaskAudit);
		}
		return resultWord;
	}

	/**
	 * 任务整理，审核保存处理
	 * 任务整理为秘书一科流程功能，整理人为其他秘书科室成员，审核人为机关党组成员，在任务部署时，被指定为督办人，是一个确定的人
	 * @param dcSupTaskAudit
	 * @return
	 */
	public void saveAuditArrange(DcSupTaskAudit dcSupTaskAudit) {
		if (StringUtils.equals(Dict.AuditType.TYPE_6, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				//修改info表的taskProgress
				dcSupTaskInfoService.updateTaskProgress(dcSupTaskAudit.getTargetId());
				// 通过后，修改状态为，通过
				dcSupTaskInfoArrangeService.updateArrangeStatus(dcSupTaskAudit.getTargetId(), "2");
			} else {
				// 驳回后，修改状态为，驳回
				dcSupTaskInfoArrangeService.updateArrangeStatus(dcSupTaskAudit.getTargetId(), "3");
				// 通知被驳回人
				this.pushMsg(dcSupTaskAudit);
			}
			// 更新审核人信息
			dcSupTaskAudit.setAuditorCode(UserUtils.getUser().getUserCode());
			dcSupTaskAudit.setAuditorName(UserUtils.getUser().getUserName());
			// 保存审核结果
			super.save(dcSupTaskAudit);
		}
		//任务整理待审核置为已办
		dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_arrange");
		// 用户提交审核时，将此处的单条消息置为已读
		sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_arrange", UserUtils.getUser().getUserCode());
	}

	/**
	 * 任务细化分解，审核保存处理
	 * @param dcSupTaskAudit
	 * @return
	 */
	public void saveAuditRefine(DcSupTaskAudit dcSupTaskAudit) {
		// 细化分解确认审核
		if (StringUtils.equals(Dict.AuditType.TYPE_8, dcSupTaskAudit.getAuditType())) {
			if (StringUtils.equals("1", dcSupTaskAudit.getAuditResult())) {
				// 通过后，修改任务状态为，细化分解任务确认审核通过
				dcSupTaskInfoRefineService.auditRefine(dcSupTaskAudit.getTargetId(), "1");
				// 将细化分解任务，分发给牵头责任单位★
				dcSupTaskInfoRefineService.distributeOrgTask(dcSupTaskAudit.getTargetId());
				//任务部署发起的置为已办
				dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_deploy");
			} else {
				// 驳回后，修改任务状态为，细化分解任务确认审核驳回
				dcSupTaskInfoRefineService.auditRefine(dcSupTaskAudit.getTargetId(), "2");
				// 通知被驳回人
				this.pushMsg(dcSupTaskAudit);
			}
			//细化分解确认审核置为已办
			dcSupBacklogService.doBacklog(dcSupTaskAudit.getId(),"task_audit_confirm");
		}
		// 保存审核结果
		super.save(dcSupTaskAudit);
		// 用户提交审核时，将此处的单条消息置为已读
		sysMsgService.makeMsgReadByBiz(dcSupTaskAudit.getId(), "audit_confirm", UserUtils.getUser().getUserCode());
	}

	/**
	 * 向过程审核表中，插入一条数据
	 * 其中，秘书一科流程反馈的科室审核、需要检查是否有人，没人的话，不能执行，有人的话，需要向子表中插入数据
	 * @param auditId 主键id
	 * @param targetId 目标id（task_id、feedback_id、arrange_id、refine_id）
	 * @param taskId 任务id
	 * @param targetType 目标类型（1任务部署、2任务反馈、3任务整理、4任务细化分解）
	 * @param auditType 审核类型（1任务部署审核、2任务部署秘书长审核、3任务反馈审核、4任务反馈科室审核、5整理任务机关党组成员(督办人)审核、6任务部署人审核、7任务部署细化分解审核、8细化分解审核）
	 * @param auditorCode 审核人编号
	 * @param auditorName 审核人名称
	 * @param auditorRole 审核人角色（NORMAL、OFFICE_MEMBER）
	 */
	public String addAuditInfo(String auditId, String targetId, String taskId, String targetType, String auditType, String auditorCode, String auditorName, String auditorRole) {
		// 记录异常反馈结果，如果正常则为空
		String resultWord = "";
		// 校验关键参数是否为空
		if (StringUtils.isNotBlank(auditId) && StringUtils.isNotBlank(targetId) && StringUtils.isNotBlank(targetType)
				&& StringUtils.isNotBlank(auditType)) {
			// 定义实体
			DcSupTaskAudit dcSupTaskAudit = new DcSupTaskAudit();
			dcSupTaskAudit.setTargetId(targetId);
			dcSupTaskAudit.setTaskId(taskId);
			dcSupTaskAudit.setTargetType(targetType);
			dcSupTaskAudit.setAuditType(auditType);

			// 某些审核类型需要判断是否可插入，是否需要向子表插入数据
			// 1任务部署审核、2任务部署秘书长审核、3任务反馈审核、5整理任务机关党组成员(督办人)审核、6任务部署人审核、7细化分解审核，直接插入
			// 4任务反馈科室审核，需要判断是否可插入
			if (StringUtils.equals(Dict.AuditType.TYPE_4, auditType)) {
				// 判断下一步是否有人，查询任务督办单位是否有用户
				DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
				// 检查督办科室是否为空，为空表示任务有问题
				if (StringUtils.isNotBlank(dcSupTaskInfo.getTaskSupOrg())) {
					List<SysBasicUser> officeMembers = sysBasicDao.getUserByOfficeAndRole(dcSupTaskInfo.getTaskSupOrg(), "SECRETARY_ONE");
					if (officeMembers != null && officeMembers.size() > 0) {
						// 将查到的科室人选插入审核子表
						this.insertAuditAdd(auditId, officeMembers);
					} else {
						resultWord = "秘书一科流程，下一步无科室人选，操作被系统驳回！";
					}
				} else {
					resultWord = "秘书一科流程，督办科室为空，操作被系统驳回！";
				}
			}

			// 补充实体信息
			if (StringUtils.isNotBlank(auditorCode) && StringUtils.isNotBlank(auditorName)) {
				dcSupTaskAudit.setAuditorCode(auditorCode);
				dcSupTaskAudit.setAuditorName(auditorName);
			}
			if (StringUtils.isNotBlank(auditorRole)) {
				dcSupTaskAudit.setAuditorRole(auditorRole);
			} else {
				dcSupTaskAudit.setAuditorRole("NORMAL");
			}

			// 记录审核状态，未审核
			dcSupTaskAudit.setAuditStatus("1");
			// 记录创建人和创建时间
			dcSupTaskAudit.setCreateBy(UserUtils.getUser().getUserCode());
			dcSupTaskAudit.setCreateByName(UserUtils.getUser().getUserName());
			dcSupTaskAudit.setCreateDate(new Date());

			// 保存，返回结果为空，表示没有异常
			if (StringUtils.isBlank(resultWord)) {
				dcSupTaskAudit.setId(auditId);
				super.insert(dcSupTaskAudit);
				// 向审核人发送通知

			}
		} else {
			resultWord = "关键参数为空！";
		}
		return resultWord;
	}

	/**
	 * 通过audit返回反馈信息
	 * @param dcSupTaskAudit
	 * @return
	 */
	public DcSupTaskFeedback getTaskFeedbackByAudit(DcSupTaskAudit dcSupTaskAudit) {
		DcSupTaskFeedback dcSupTaskFeedback = new DcSupTaskFeedback();
		// 只有反馈才能返回
		if (StringUtils.equals("2", dcSupTaskAudit.getTargetType())) {
			dcSupTaskFeedback = dcSupTaskFeedbackService.get(dcSupTaskAudit.getTargetId());
		}

		return dcSupTaskFeedback;
	}

	/**
	 * 向审核表的子表中插入数据
	 * @param list
	 */
	public void insertAuditAdd(String auditId, List<SysBasicUser> list) {
		for (SysBasicUser item : list) {
			DcSupTaskAuditAdd dcSupTaskAuditAdd = new DcSupTaskAuditAdd();
			dcSupTaskAuditAdd.setAuditId(auditId);
			dcSupTaskAuditAdd.setAuditorCode(item.getUserCode());
			dcSupTaskAuditAdd.setAuditorName(item.getUserName());
			// 设置为生效
			dcSupTaskAuditAdd.setUseFlag("1");
			dcSupTaskAuditAddService.save(dcSupTaskAuditAdd);
		}
	}

	/**
	 * 通过审核id，和审核人编号，将其他的审核人设置为失效
	 * @param dcSupTaskAudit
	 */
	public void updateAuditAdd(DcSupTaskAudit dcSupTaskAudit) {
		dcSupTaskAuditAddService.disableUseFlagByIdAndCode(dcSupTaskAudit.getId(), dcSupTaskAudit.getAuditorCode());
	}

	/**
	 * 推送信息给被驳回人
	 * @param dcSupTaskAudit
	 */
	public void pushMsg(DcSupTaskAudit dcSupTaskAudit) {
//		PcMsgContent msg = new PcMsgContent();
//		msg.setTitle("提示信息");
		// 获取审核意见
		String auditOption = StringUtils.isBlank(dcSupTaskAudit.getAuditOption()) ? "未填写意见" : dcSupTaskAudit.getAuditOption();
		// 任务部署
		if (StringUtils.equals(Dict.TargetType.TYPE_1, dcSupTaskAudit.getTargetType())) {
//			msg.setContent("您有一条任务部署被审核打回！请重新提交！\n 审核意见：" + auditOption);
			String href = "";
			if (StringUtils.equals(Dict.AuditType.TYPE_7, dcSupTaskAudit.getAuditType())) {
				// 任务部署中的细化分解部署，驳回后，跳转地址和其他的任务部署不同
//				msg.addButton("编辑督办事项", "/a/taskdeploy/dcSupTaskInfoRefine/form?id=" + dcSupTaskAudit.getTargetId());
				href="/a/taskdeploy/dcSupTaskInfoRefine/form?id=" + dcSupTaskAudit.getTargetId();
			} else {
//				msg.addButton("编辑督办事项", "/a/taskdeploy/dcSupTaskInfo/form?id=" + dcSupTaskAudit.getTargetId());
				href="/a/taskdeploy/dcSupTaskInfo/form?id=" + dcSupTaskAudit.getTargetId();
			}
//			MsgPushUtils.push(msg, dcSupTaskAudit.getTaskId(), "audit_reject_deploy", dcSupTaskAudit.getDcSupTaskInfo().getCreateBy());
			//发送易政网消息
			MsgDetail msgDetail = new MsgDetail();
			msgDetail.setSendid(UserUtils.getUser().getUserCode());
			msgDetail.setSubjectid(dcSupTaskAudit.getDcSupTaskInfo().getCreateBy());
			msgDetail.setMesg("您有一条任务部署被审核打回！请登录系统查看！");
			lehandYzwPushTask.pushYzwShortMsg(msgDetail);
			//新增待办
			DcSupBacklog add = dcSupBacklogService.add("督查督办", "审核驳回", "任务部署审核驳回", "提示信息"
					, "您有一条任务部署被审核打回！请重新提交！\n 审核意见：" + auditOption
					, href, ""
					, dcSupTaskAudit.getTaskId(), "task_deploy", dcSupTaskAudit.getDcSupTaskInfo().getCreateBy()
					, dcSupTaskAudit.getDcSupTaskInfo().getId(), "");
//			Map<String,String> message = new HashMap<>();
//			message.put("id",add.getId());
//			message.put("title","任务部署审核驳回");
//			message.put("message","您有一条任务部署被审核打回！请重新提交！\n 审核意见：" + auditOption);
//			message.put("senderId",UserUtils.getUser().getExtend().getExtendS3());
//			message.put("senderName",UserUtils.getUser().getUserName());
//			String s = dcSupBacklogService.addWZTPending(message,dcSupTaskAudit.getDcSupTaskInfo().getCreateBy());
//			dcSupBacklogService.updateWZTaddMessage2Bacnklog(add.getId(),s);
		}
		// 任务反馈
		if (StringUtils.equals(Dict.TargetType.TYPE_2, dcSupTaskAudit.getTargetType())) {
//			msg.setContent("您有一条任务反馈被审核打回！请重新提交！\n 审核意见：" + auditOption);
//			msg.addButton("编辑任务反馈", "/a/audit/taskReceive/taskReceiveOne?id=" + dcSupTaskAudit.getTargetId());
//			MsgPushUtils.push(msg, dcSupTaskAudit.getDcSupTaskFeedback().getId(), "audit_reject_feedback", dcSupTaskAudit.getDcSupTaskFeedback().getUpdateBy());
			//发送易政网消息
			MsgDetail msgDetail = new MsgDetail();
			msgDetail.setSendid(UserUtils.getUser().getUserCode());
			msgDetail.setSubjectid(dcSupTaskAudit.getDcSupTaskFeedback().getUpdateBy());
			msgDetail.setMesg("您有一条任务反馈被审核打回！请登录系统查看！");
			lehandYzwPushTask.pushYzwShortMsg(msgDetail);
			//新增待办
			dcSupBacklogService.add("督查督办","审核驳回","任务反馈审核驳回","提示信息"
					,"您有一条任务部署被审核打回！请重新提交！\n 审核意见：" + auditOption
					,"/a/audit/taskReceive/taskReceiveOne?id=" + dcSupTaskAudit.getTargetId(),""
					,dcSupTaskAudit.getTargetId(),"task_feedback",dcSupTaskAudit.getDcSupTaskFeedback().getUpdateBy()
					,dcSupTaskAudit.getTaskId(),dcSupTaskAudit.getDcSupTaskFeedback().getActionId());

		}
		// 任务整理
		if (StringUtils.equals(Dict.TargetType.TYPE_3, dcSupTaskAudit.getTargetType())) {
			DcSupTaskInfo tempTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
//			msg.setContent("您有一条任务整理被审核打回！请重新提交！\n 任务名称为：" + tempTaskInfo.getTaskTitle() + "\n 审核意见：" + auditOption);
//			msg.addButton("任务整理", "/a/taskdeploy/dcSupTaskInfo/arrangeTask?taskId=" + tempTaskInfo.getId());
//			MsgPushUtils.push(msg, dcSupTaskAudit.getTaskId(), "audit_reject_arrange", dcSupTaskAudit.getCreateBy());
			//发送易政网消息
			MsgDetail msgDetail = new MsgDetail();
			msgDetail.setSendid(UserUtils.getUser().getUserCode());
			msgDetail.setSubjectid(dcSupTaskAudit.getCreateBy());
			msgDetail.setMesg("您有一条任务整理被审核打回！请登录系统查看！");
			lehandYzwPushTask.pushYzwShortMsg(msgDetail);
		}
		// 任务细化分解
		if (StringUtils.equals(Dict.TargetType.TYPE_4, dcSupTaskAudit.getTargetType())) {
//			msg.setContent("您有一条任务阶段目标报送被审核打回！请重新提交！\n 审核意见：" + auditOption);
//			msg.addButton("任务阶段目标报送", "/a/taskdeploy/dcSupTaskInfoRefine/refineForm?id=" + dcSupTaskAudit.getTargetId());
//			MsgPushUtils.push(msg, dcSupTaskAudit.getTaskId(), "audit_reject_refine", dcSupTaskAudit.getCreateBy());
			//发送易政网消息
			MsgDetail msgDetail = new MsgDetail();
			msgDetail.setSendid(UserUtils.getUser().getUserCode());
			msgDetail.setSubjectid(dcSupTaskAudit.getCreateBy());
			msgDetail.setMesg("您有一条任务阶段目标报送被审核打回！请登录系统查看！");
			lehandYzwPushTask.pushYzwShortMsg(msgDetail);
			//新增待办
			DcSupTaskInfoRefine taskInfoRefine = dcSupTaskInfoRefineService.get(dcSupTaskAudit.getTargetId());
			dcSupBacklogService.add("督查督办","审核驳回","任务阶段目标报送驳回","提示信息"
					,"您有一条任务阶段目标报送被审核打回！请重新提交！\n 审核意见：" + auditOption
					,"/a/taskdeploy/dcSupTaskInfoRefine/refineForm?id=" + dcSupTaskAudit.getTargetId(),taskInfoRefine.getTaskLeaderOrg()
					,dcSupTaskAudit.getTaskId(),"task_refine",dcSupTaskAudit.getCreateBy()
					,dcSupTaskAudit.getTaskId(),"");
		}
	}

	public Page<DcSupTaskAuditInfoApp> queryAuditInfoListApp(DcSupTaskAuditInfoApp auditInfo) {
		Page<DcSupTaskAuditInfoApp> page = auditInfo.getPage();
		List<DcSupTaskAuditInfoApp> list = dao.queryAuditInfoListApp(auditInfo);
		for (int i = 0; i < list.size(); i++) {
			if(StringUtils.isNotBlank(list.get(i).getMessageNumber())){
				list.get(i).setMsgNum(list.get(i).getMessageNumber().substring(0,list.get(i).getMessageNumber().indexOf("〕")+1));
				list.get(i).setMsgNum2(list.get(i).getMessageNumber().substring(list.get(i).getMessageNumber().indexOf("〕")+1));
			}
		}
		page.setList(list);
		return page;
	}

	public Page<DcSupTaskAuditFeedbackApp> queryAuditFeedbackListApp(DcSupTaskAuditFeedbackApp auditInfo) {
		Page<DcSupTaskAuditFeedbackApp> page = auditInfo.getPage();
		List<DcSupTaskAuditFeedbackApp> list = dao.queryAuditFeedbackListApp(auditInfo);
		page.setList(list);
		return page;
	}

	public DcSupTaskAuditArrangeApp queryAuditArrangeFormApp(DcSupTaskAuditArrangeApp auditInfo) {
		return dao.queryAuditArrangeFormApp(auditInfo);
	}

	/**
	 *
	 * @param targetId 反馈表id
	 * @param auditType 传3任务反馈审核、4任务反馈科室审核、5任务反馈部署人审核
	 * @return
	 */
	public List<DcSupTaskAudit> getAuditListInfo(String targetId,String auditType){
		return dao.getAuditListInfo(targetId,"1","2",auditType);
	}

	/**
	 * 删除因网络卡多次反馈的审核
	 * @param targetId
	 * @param auditType
	 */
	public void deleteAuditFeedback(String targetId,String auditType){
		dao.deleteAuditFeedback(targetId,"1","2",auditType);
	}
}